Wat doet "use strict" in JavaScript, en wat is de redenering erachter?

Dit artikel over Javascript Strict Mode kan je interesseren: John Resig - ECMAScript 5 Strict Mode, JSON en meer
Om enkele interessante onderdelen te citeren:
Strict Mode is een nieuwe functie in ECMAScript 5 waarmee u een programma of een functie in een "strikte" operationele context kunt plaatsen. Deze strikte context voorkomt dat bepaalde acties worden ondernomen en werpt meer uitzonderingen op.
En:
De strikte modus helpt op een aantal manieren:
Het vangt enkele veelvoorkomende coderings-bloopers op, met uitzonderingen.
Het voorkomt, of genereert fouten, wanneer relatief "onveilige" acties worden ondernomen (zoals toegang krijgen tot het globale object).
Het schakelt functies uit die verwarrend of slecht doordacht zijn.
Merk ook op dat je de "strikte modus" kunt toepassen op het hele bestand ... Of je kunt het alleen gebruiken voor een specifieke functie (nog steeds citerend uit het artikel van John Resig):
// Niet-strikte code ...
(functie(){
"gebruik strikt";
// Definieer uw bibliotheek strikt ...
}) ();
// Niet-strikte code ...
Wat handig kan zijn als je oude en nieuwe code moet combineren ;-)
Dus ik neem aan dat het een beetje lijkt op de "use strict" die je kunt gebruiken in Perl (vandaar de naam?): Het helpt je om minder fouten te maken, door meer dingen te detecteren die tot breuken kunnen leiden.
De strikte modus wordt nu ondersteund door alle grote browsers.
Binnen native ECMAScript-modules (met import- en exportverklaringen) en ES6-klassen is de strikte modus altijd ingeschakeld en kan deze niet worden uitgeschakeld.
|
Het is een nieuwe feature van ECMAScript 5. John Resig heeft er een mooie samenvatting van gemaakt.
Het is gewoon een tekenreeks die u in uw JavaScript-bestanden plaatst (bovenaan uw bestand of in een functie) die er als volgt uitziet:
"gebruik strikt";
Als u het nu in uw code invoert, zou dit geen problemen moeten veroorzaken met de huidige browsers, aangezien het maar een string is. Het kan in de toekomst problemen met uw code veroorzaken als uw code in strijd is met de pragma. Als je bijvoorbeeld momenteel foo = "bar" hebt zonder eerst foo te definiëren, zal je code beginnen te falen ... wat naar mijn mening een goede zaak is.
|
De verklaring "gebruik strikt"; instrueert de browser om de strikte modus te gebruiken, wat een gereduceerde en veiligere functieset van JavaScript is.
Lijst met functies (niet uitputtend)
Staat globale variabelen niet toe. (Vangt ontbrekende var-declaraties en typefouten op in variabelenamen)
Stille falende toewijzingen zullen een fout veroorzaken in de strikte modus (toewijzen van NaN = 5;)
Pogingen om onherstelbare eigenschappen te verwijderen, veroorzaken (delete Object.prototype)
Vereist dat alle eigenschapsnamen in een letterlijk object uniek zijn (var x = {x1: "1", x1: "2"})
Namen van functieparameters moeten uniek zijn (functie som (x, x) {...})
Verbiedt octale syntaxis (var x = 023; sommige ontwikkelaars gaan er ten onrechte van uit dat een voorafgaande nul niets doet om het getal te veranderen.)
Verbiedt het trefwoord with
eval in strikte modus introduceert geen nieuwe variabelen
Verbiedt het verwijderen van gewone namen (verwijder x;)
Verbiedt het binden of toewijzen van de namen eval en argumenten in welke vorm dan ook
De strikte modus geeft geen alias aan de eigenschappen van het arguments-object met de formele parameters. (d.w.z. in functie som (a, b) {retourneer argumenten [0] + b;} Dit werkt omdat argumenten [0] gebonden zijn aan a enzovoort.)
arguments.callee wordt niet ondersteund
[Ref: Strikte modus, Mozilla Developer Network]
|
Als mensen zich zorgen maken over het gebruik van strikt gebruik, is het misschien de moeite waard om dit artikel te lezen:
ECMAScript 5 'Strikte modus' ondersteuning in browsers. Wat betekent dit NovoGeek.com - Krishna's weblog
Er wordt gesproken over browserondersteuning, maar nog belangrijker, hoe u er veilig mee om kunt gaan:
functie isStrictMode () {
terug! dit;
}
/ *
geeft false terug, aangezien 'dit' verwijst naar globaal object en
'! this' wordt vals
* /
functie isStrictMode () {
"gebruik strikt";
terug! dit;
}
/ *
geeft waar terug, aangezien in de strikte modus het trefwoord 'dit'
verwijst niet naar globaal object, in tegenstelling tot traditionele JS.
Dus hier is 'dit' 'ongedefinieerd' en '! Dit' wordt waar.
* /
|
Een woord van waarschuwing, allemaal hardladende programmeurs: het toepassen van "use strict" op bestaande code kan gevaarlijk zijn! Dit ding is niet een of andere feel-good, happy-face sticker die je op de code kunt plakken om hem 'beter' te maken. Met de "use strict" pragma, zal de browser plotseling uitzonderingen WEGWERPEN op willekeurige plaatsen die hij nooit eerder heeft gegooid, alleen omdat je op die plek iets doet dat standaard / losse JavaScript graag toestaat, maar strikt JavaScript verafschuwt! U kunt strikte overtredingen hebben die zich verbergen in zelden gebruikte aanroepen in uw code die alleen een uitzondering veroorzaken wanneer ze uiteindelijk worden uitgevoerd, bijvoorbeeld in de productieomgeving die uw betalende klanten gebruiken!
Als je de sprong wilt wagen, is het een goed idee om naast uitgebreide unit tests en een strikt geconfigureerde JSHint build-taak "use strict" toe te passen, die je enig vertrouwen geeft dat er geen donkere hoek van je module is die ontploft vreselijk alleen omdat je de strikte modus hebt ingeschakeld. Of, hey, hier is nog een andere optie: voeg gewoon geen "use strict" toe aan uw oude code, het is waarschijnlijk veiliger op die manier, eerlijk gezegd. VOEG ZEKER GEEN "use strict" toe aan modules die u niet bezit ofonderhouden, zoals modules van derden.
Ik denk dat hoewel het een dodelijk gekooid dier is, "gebruik streng" goed kan zijn, maar je moet het goed doen. De beste tijd om streng te zijn, is wanneer uw project greenfield is en u helemaal opnieuw begint. Configureer JSHint / JSLint met alle waarschuwingen en opties zo strak als je team kan verdragen, krijg een goed build / test / assert-systeem du jour opgetuigd zoals Grunt + Karma + Chai, en pas DAN begin je al je nieuwe modules te markeren als " gebruik strict ". Wees voorbereid om veel kleine fouten en waarschuwingen te verhelpen. Zorg ervoor dat iedereen de ernst begrijpt door de build te configureren op FAIL als JSHint / JSLint overtredingen produceert.
Mijn project was geen greenfield-project toen ik "use strict" adopteerde. Het resultaat is dat mijn IDE vol rode markeringen zit omdat ik geen "use strict" heb op de helft van mijn modules, en JSHint klaagt daarover. Het is een herinnering voor mij over wat ik in de toekomst moet refactoren. Mijn doel is om een ​​rode stip vrij te zijn vanwege al mijn ontbrekende "gebruik strikte" uitspraken, maar dat is nu jaren weg.
|
Gebruik van 'use strict'; maakt uw code niet plotseling beter.
De JavaScript-strikte modus is een functie in ECMAScript 5. U kunt de strikte modus inschakelen door dit bovenaan uw script / functie aan te geven.
'gebruik strikt';
Wanneer een JavaScript-engine deze instructie ziet, begint deze de code in een speciale modus te interpreteren. In deze modus worden fouten gegenereerd wanneer bepaalde coderingspraktijken worden gedetecteerd die potentiële bugs zouden kunnen zijn (wat de redenering is achter de strikte modus).
Beschouw dit voorbeeld eens:
var a = 365;
var b = 030;
In hun obsessie om de numerieke literalen op één lijn te brengen, heeft de ontwikkelaar per ongeluk variabele b geïnitialiseerd met een octale literaal. De niet-strikte modus zal dit interpreteren als een numerieke letterlijke waarde met waarde 24 (in grondtal 10). De strikte modus genereert echter een fout.
Zie dit antwoord voor een niet-uitputtende lijst van specialiteiten in strikte modus.
Waar moet ik 'use strict' gebruiken ;?
In mijn nieuwe JavaScript-applicatie: Absoluut! De strikte modus kan worden gebruikt als klokkenluider wanneer u iets stoms doet met uw code.
In mijn bestaande JavaScript-code: waarschijnlijk niet! Als uw bestaande JavaScript-code uitspraken heeft die in strikte modus verboden zijn, zal de toepassing gewoon breken. Als u een strikte modus wilt, moet u bereid zijn om uw bestaande code te debuggen en te corrigeren. Dit is de reden waarom het gebruik van 'use strict'; maakt uw code niet ineens beter.
Hoe gebruik ik de strikte modus?
Voeg een 'use strict' in; verklaring bovenop je script:
// Bestand: myscript.js
'gebruik strikt';
var a = 2;
....
Merk op dat alles in het bestand myscript.js in strikte modus zal worden geïnterpreteerd.
Of voeg een 'use strict' in; verklaring bovenop uw functie body:
functie doSomething () {
'gebruik streng';
...
}
Alles in de lexicale reikwijdte van de functie doSomething zal in strikte modus worden geïnterpreteerd. Het woord lexicale reikwijdte is hier belangrijk. Als uw strikte code bijvoorbeeld een functie van een bibliotheek aanroept die niet strikt is, wordt alleen uw code uitgevoerd in de strikte modus en niet de aangeroepen functie. Zie dit antwoord voor een betere uitleg.
Welke dingen zijn verboden in de strikte modus?
Ik vond een leuk artikel dat verschillende dingen beschrijft die verboden zijn in de strikte modus (merk op dat dit geen exclusieve lijst is):
Reikwijdte
Historisch gezien was JavaScript in de war over hoe functioneert
zijn scoped. Soms lijken ze een statisch bereik te hebben, maar sommige
functies zorgen ervoor dat ze zich gedragen alsof ze een dynamisch bereik hebben. Dit is
verwarrend, waardoor programma's moeilijk te lezen en te begrijpen zijn.
Misverstanden veroorzaken bugs. Het is ook een probleem voor de prestaties.
Statische scoping zou het mogelijk maken dat variabele binding plaatsvindt tijdens het compileren
tijd, maar de vereiste voor dynamische reikwijdte betekent dat de binding moet zijn
uitgesteld tot runtime, wat gepaard gaat met aanzienlijke prestaties
straf.
De strikte modus vereist dat alle variabele binding statisch wordt uitgevoerd.
Dat betekent dat de functies die voorheen dynamische binding vereisten
moet worden geëlimineerd of gewijzigd. In het bijzonder is de met-verklaring
geëlimineerd, en het vermogen van de evaluatiefunctie om te knoeien met de
omgeving van de beller is ernstig beperkt.
Een van de voordelen van strikte code is dat tools zoals YUI Compressor
kan het beter doen bij het verwerken ervan.
Geïmpliceerde globale variabelen
JavaScript heeft globale variabelen geïmpliceerd. Als
je declareert niet expliciet een variabele, een globale variabele is dat wel
impliciet voor u verklaard. Dit maakt het programmeren gemakkelijker voor
beginners omdat ze een deel van hun elementaire huishouding kunnen verwaarlozen
klusjes. Maar het maakt het beheer van grotere programma's veel meer
moeilijk en het vermindert de betrouwbaarheid aanzienlijk. Dus strikt
modus worden geïmpliceerde globale variabelen niet langer gemaakt. Je zou moeten
verklaar expliciet al uw variabelen.
Wereldwijde lekkage
Er zijn een aantal situaties die dit kunnen veroorzaken
gebonden zijn aan het globale object. Bijvoorbeeld als u vergeet
geef het nieuwe voorvoegsel op bij het aanroepen van een constructorfunctie, de
constructor zal dit onverwachts aan het globale object worden gebonden, dus
in plaats van een nieuw object te initialiseren, zal het in plaats daarvan stil zijn
knoeien met globale variabelen. In deze situaties zal de strikte modus
bind dit in plaats daarvan aan undefined, wat ervoor zorgt dat de constructor
gooi in plaats daarvan een uitzondering, waardoor de fout veel kan worden gedetecteerd
eerder.
Lawaaierige storing
JavaScript heeft altijd alleen-lezen eigenschappen gehad, maar jij
kon ze pas zelf maken als Object.createProperty van ES5
functie legde dat vermogen bloot. Als u heeft geprobeerd een waarde toe te wijzen
naar een alleen-lezen eigenschap, zou het stil mislukken. De opdracht zou
de waarde van de eigenschap niet veranderen, maar uw programma zou doorgaan als
hoewel het had. Dit is een integriteitsrisico dat programma's kan veroorzaken
gaan in een inconsistente staat. Probeer in strikte modus een
alleen-lezen eigenschap genereert een uitzondering.
Octaal
De octale (of basis 8) weergave van getallen was extreem
handig bij het programmeren op machineniveau op machines waarvan het woord
maten waren een veelvoud van 3. Je had octaal nodig als je met de CDC werkte
6600 mainframe, met een woordgrootte van 60 bits. Als je kon lezen
octaal, je zou naar een woord kunnen kijken als 20 cijfers. Twee cijfers vertegenwoordigd
de op-code en een cijfer identificeerde een van de 8 registers. Tijdens de
trage overgang van machinecodes naar talen op hoog niveau, het was
dacht nuttig te zijn om octale vormen in programmeertalen aan te bieden.
In C was dat een buitengewoon ongelukkige voorstelling van octaalheid
geselecteerd: voorloopnul. Dus in C betekent 0100 64, niet 100, en 08 is een
fout, niet 8. Helaas is dit anachronisme nog meer geweest
gekopieerd in bijna alle moderne talen, inclusief JavaScript, waar
het wordt alleen gebruikt om fouten te creëren. Het heeft geen ander doel. Dus in
strikte modus, zijn octale vormen niet langer toegestaan.
Enz
De pseudo-array met argumenten wordt een beetje meer
array-achtig in ES5. In de strikte modus verliest het zijn aangeroepen en beller
eigendommen. Dit maakt het mogelijk om uw argumenten door te geven aan niet-vertrouwd
code zonder veel vertrouwelijke context op te geven. Ook de
arguments eigenschap van functies is geëlimineerd.
In de strikte modus zullen dubbele sleutels in een letterlijke functie een
syntax error. Een functie mag niet twee parameters met dezelfde naam hebben.
Een functie kan geen variabele hebben met dezelfde naam als een van zijn
parameters. Een functie kan zijn eigen variabelen niet verwijderen. Een poging om
delete a niet-configureerbare eigenschap genereert nu een uitzondering. Primitief
waarden zijn niet impliciet verpakt.
Gereserveerde woorden voor toekomstige JavaScript-versies
ECMAScript 5 voegt een lijst met gereserveerde woorden toe. Als u ze als variabelen of argumenten gebruikt, genereert de strikte modus een fout. De gereserveerde woorden zijn:
implementeert, interface, let, pakket, privé, beschermd, openbaar, statisch en opbrengst
Verder lezen
Strikte modus - JavaScript | MDN
Browserondersteuning voor strikte modus
Overgang naar strikte modus
|
Ik raad elke ontwikkelaar ten zeerste aan om nu de strikte modus te gaan gebruiken. Er zijn voldoende browsers die dit ondersteunen, zodat de strikte modus ons legitiem kan redden van fouten waarvan we niet eens wisten dat ze in uw code zaten.
Blijkbaar zullen er in de beginfase fouten zijn die we nog nooit eerder zijn tegengekomen. Om het volledige voordeel te behalen, moeten we de juiste tests uitvoeren nadat we naar de strikte modus zijn overgeschakeld om er zeker van te zijn dat we alles hebben opgevangen. We gooien absoluut niet alleen het gebruik strict in onze code en gaan ervan uit dat er geen fouten zijn. Dus het verloop is dat het tijd is om deze ongelooflijk nuttige taalfunctie te gaan gebruiken om betere code te schrijven.
Bijvoorbeeld,
var persoon = {
naam: 'xyz',
positie: 'abc',
volledige naam: function () {"use strict"; retourneer this.name; }
};
JSLint is een debugger geschreven door Douglas Crockford. Plak gewoon uw script en het scant snel op zichtbare problemen en fouten in uw code.
|
Ik zou graag een wat meer gefundeerd antwoord willen geven als aanvulling op de andere antwoorden. Ik hoopte het meest populaire antwoord te bewerken, maar dat mislukte. Ik heb geprobeerd het zo volledig en compleet mogelijk te maken.
U kunt de MDN-documentatie raadplegen voor meer informatie.
"use strict" een richtlijn geïntroduceerd in ECMAScript 5.
Richtlijnen lijken op verklaringen, maar zijn toch verschillend.
use strict bevat geen sleutelwoorden: de instructie is een eenvoudige uitdrukking, die bestaat uit een speciale letterlijke tekenreeks (in enkele of dubbele aanhalingstekens). JavaScript-engines die ECMAScript 5 niet implementeren, zien alleen een uitdrukkingsverklaring zonder bijwerkingen. Verwacht wordt dat toekomstige versies van ECMAScript-standaarden het gebruik als een echt sleutelwoord introduceren; de citaten zouden daardoor achterhaald raken.
use strict kan alleen aan het begin van een script of functie worden gebruikt, d.w.z. het moet voorafgaan aan elke andere (echte) instructie. Het hoeft niet de eerste instructie in een functioneel script te zijn: het kan worden voorafgegaan door andere instructie-expressies die bestaan ​​uit letterlijke tekenreeksen (en JavaScriptimplementaties kunnen ze behandelen als implementatiespecifieke richtlijnen). Letterlijke tekenreeksen, die volgen op een eerste echte instructie (in een script of functie), zijn eenvoudige uitdrukkingsinstructies. Tolken mogen ze niet als richtlijnen interpreteren en hebben geen effect.
De use strict-instructie geeft aan dat de volgende code (in een script of een functie) strikte code is.
De code op het hoogste niveau van een script (code die niet in een functie staat) wordt als strikte code beschouwd als het script een use strict-instructie bevat.
De inhoud van een functie wordt als strikte code beschouwd als de functie zelf is gedefinieerd in een strikte code of als de functie een strikte instructie voor gebruik bevat.
Code die wordt doorgegeven aan een methode eval () wordt als strikte code beschouwd wanneer eval () werd aangeroepen vanuit een strikte code of de instructie strikte gebruik zelf bevat.
De strikte modus van ECMAScript 5 is een beperkte subset van de JavaScript-taal, die relevante taaltekorten elimineert en beschikt over strengere foutcontrole en hogere beveiliging. Het volgende geeft een overzicht van de verschillen tussen de strikte modus en de normale modus (waarvan de eerste drie bijzonder belangrijk zijn):
U kunt de with-statement niet gebruiken in de strikte modus.
In de strikte modus moeten alle variabelen worden gedeclareerd: als je een waarde toekent aan een identifier die niet is gedeclareerd als variabele, functie, functieparameter, catch-clause parameter of eigenschap van het globale Object, dan krijg je een ReferenceError. In de normale modus wordt de identifier impliciet gedeclareerd als een globale variabele (als een eigenschap van het globale object)
In strikte modus heeft het trefwoord dit de waarde ongedefinieerd in functies die werden aangeroepen als functies (niet als methoden). (In de normale modus wijst dit altijd naar het globale object). Dit verschil kan worden gebruikt om te testen of een implementatie de strikte modus ondersteunt:
var hasStrictMode = (function () {"use strict"; retourneer dit === undefined} ());
Ook wanneer een functie wordt aangeroepen met call () of apply in strikte modus, dan is dit precies de waarde van het eerste argument van de aanroep call () of apply (). (In de normale modus worden null en ongedefinieerd vervangen door het globale object en worden waarden, die geen objecten zijn, in objecten gegoten.)
In strikte modus krijgt u een TypeError, wanneer u probeert toe te wijzen aan alleen-lezen eigenschappen of om nieuwe eigenschappen te definiëren voor een niet-uitbreidbaar object. (In de normale modus mislukken beide eenvoudig zonder foutmelding.)
In strikte modus, wanneer u code doorgeeft aan eval (), kunt u geen variabelen of functies binnen het bereik van de beller declareren of definiëren (zoals u dat wel kunt doen in de normale modus). In plaats daarvan wordt een nieuw bereik gemaakt voor eval () en de variabelen en functies vallen binnen dat bereik. Die scope wordt vernietigd nadat eval () de uitvoering heeft voltooid.
In de strikte modus bevat het arguments-object van een functie een statische kopie van de waarden die aan die functie worden doorgegeven. In de normale modus heeft het arguments-object een ietwat "magisch" gedrag: de elementen van de array en de genoemde functieparameters verwijzen beide naar dezelfde waarde.
In strikte modus krijgt u een SyntaxError wanneer de delete-operator wordt gevolgd door een niet-gekwalificeerde identifier (een variabele, functie of functieparameter). In de normale modus zou de delete-expressie niets doen en wordt deze geëvalueerd als false.
In strikte modus krijgt u een TypeError wanneer u een niet-configureerbare eigenschap probeert te verwijderen. (In de normale modus mislukt de poging gewoon en wordt de delete-expressie geëvalueerd als false).
In strikte modus wordt het als een syntactische fout beschouwd wanneer u probeert om verschillende eigenschappen met dezelfde naam voor een letterlijk object te definiëren. (In de normale modus is er geen fout.)
In strikte modus wordt het als een syntactische fout beschouwd wanneer een functiedeclaratie meerdere parameters met dezelfde naam heeft. (In de normale modus is er geen fout.)
In strikte modus zijn octale literalen niet toegestaan ​​(dit zijn literalen die beginnen met 0x. (In normale modus zijn sommige implementaties octale literalen wel toegestaan).)
In strikte modus worden de identificatoren eval en argumenten behandeld als sleutelwoorden. U kunt hun waarde niet wijzigen, u kunt er geen waarde aan toewijzen, en u kunt ze niet gebruiken als namen voor variabelen, functies, functieparameters of identifiers van een catch-blok.
In de strikte modus zijn er meer beperkingen op de mogelijkheden om de call-stack te onderzoeken. arguments.caller en arguments.callee veroorzaken een TypeError in een functie in de strikte modus. Bovendien veroorzaken sommige caller- en argumenten-eigenschappen van functies in strikte modus een TypeError wanneer u ze probeert te lezen.
|
Mijn twee cent:
Een van de doelen van de strikte modus is om snellere foutopsporing van problemen mogelijk te maken. Het helpt de ontwikkelaars door een uitzondering te maken wanneer bepaalde verkeerde dingen gebeuren die stil en vreemd gedrag van uw webpagina kunnen veroorzaken. Op het moment dat we strict gebruiken, zal de code fouten weggooien waardoor de ontwikkelaar dit van tevoren kan oplossen.
Enkele belangrijke dingen die ik heb geleerd na gebruik strikt:
Voorkomt Global Variable Declaration:
var tree1Data= {naam: 'Banana Tree', leeftijd: 100, leafCount: 100000};
functie Tree (typeOfTree) {
var leeftijd;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = nieuwe Tree (tree1Data);
console.log (venster);
Nu creëert deze code nameoftree in globaal bereik waartoe toegang kan worden verkregen via window.nameoftree. Wanneer we use strict implementeren, zou de code een fout veroorzaken.
Uncaught ReferenceError: nameoftree is niet gedefinieerd
Monster
Elimineert met verklaring:
with statements kunnen niet verkleind worden met tools zoals uglify-js. Ze zijn ook verouderd en verwijderd uit toekomstige JavaScript-versies.
Monster
Voorkomt duplicaten:
Als we een dubbele eigenschap hebben, genereert dit een uitzondering
Uncaught SyntaxError: dubbele gegevenseigenschap in letterlijk object niet
toegestaan ​​in strikte modus
"gebruik strikt";
var tree1Data = {
naam: 'Banana Tree',
leeftijd: 100,
leafCount: 100000,
naam: 'Banana Tree'
};
Er zijn er nog een paar, maar daar moet ik meer kennis over opdoen.
|
Als u een browser gebruikt die in het afgelopen jaar is uitgebracht, ondersteunt deze hoogstwaarschijnlijk de JavaScript Strict-modus. Alleen oudere browsers voordat ECMAScript 5 de huidige standaard werd, ondersteunen dit niet.
De aanhalingstekens rond het commando zorgen ervoor dat de code ook in oudere browsers zal werken (hoewel de dingen die een syntaxisfout genereren in de strikte modus er over het algemeen alleen voor zorgen dat het script op een moeilijk te detecteren manier defect raakt in die oudere browsers).
|
Wanneer u "use strict"; toevoegt, zullen de volgende gevallen een SyntaxError genereren voordat het script wordt uitgevoerd:
De weg effenen voor toekomstige ECMAScript-versies, gebruikmakend van een van de nieuw gereserveerde sleutelwoorden (in afwachting van ECMAScript 6): implementaties, interface, let, pakket, privé, beschermd, openbaar, statisch en opbrengst.
Declaratiefunctie in blokken
if (a : 3: 15)
bij : 6: 5
Hier gooit de compiler de referentiefout. In strikte modus staat de compiler ons niet toe de variabele te gebruiken zonder deze te declareren. Zo kunnen geheugenlekken worden voorkomen. Bovendien kunnen we meer geoptimaliseerde code schrijven.
|
De strikte modus elimineert fouten die zouden worden genegeerd in de niet-strikte modus, waardoor javascript "beter beveiligd" wordt.
Wordt het beschouwd als een van de beste praktijken?
Ja, het wordt beschouwd als onderdeel van de best practices tijdens het werken met javascript om de strikte modus op te nemen. Dit wordt gedaan door de onderstaande regel code toe te voegen aan uw JS-bestand.
'gebruik streng';
in uw code.
Wat betekent het voor user agents?
Door aan te geven dat code in strikte modus moet worden geïnterpreteerd, wordt voor user agents zoals browsers gespecificeerd dat ze code letterlijk als geschreven moeten behandelen en een foutmelding genereren als de code niet klopt.
Bijvoorbeeld: stel dat je in je .js-bestand de volgende code hebt:
Scenario 1: [GEEN STRIKTE MODUS]
var city = "Chicago"
console.log (city) // Drukt de plaatsnaam af, d.w.z. Chicago
Scenario 2: [GEEN STRIKTE MODUS]
city ​​= "Chicago"
console.log (city) // Drukt de plaatsnaam af, d.w.z. Chicago
Dus waarom wordt de variabelenaam in beide gevallen afgedrukt?
Als de strikte modus niet is ingeschakeld, ondergaan user agents vaak een reeks wijzigingen aan problematische code in een poging om het logisch te maken. Op het eerste gezicht lijkt dit een mooie zaak, en inderdaad, door buiten de strikte modus te werken, kunnen mensen hun voeten nat maken met JavaScript-code zonder dat alle details helemaal vast zitten. Als ontwikkelaar wil ik echter geen bug in mijn code achterlaten, omdat ik weet dat het later terug kan komen en me bijten, en ik wil ook gewoon goede code schrijven. En dat is waar de strikte modus helpt.
Scenario 3: [STRIKTE MODUS]
'gebruik streng';
city ​​= "Chicago"
console.log (city) // Referentiefout: toewijzing is niet-aangegeven variabele stad.
Extra tip: om de codekwaliteit te behouden in de strikte modus, hoeft u dit niet steeds opnieuw te schrijven, vooral als u meerdere .js-bestanden hebt. U kunt deze regel als volgt globaal afdwingen in eslint-regels:
Bestandsnaam: .eslintrc.js
module.exports = {
env: {
es6: waar
},
reglement : {
strict: ['error', 'global'],
},
};
Oké, dus wat wordt voorkomen in de strikte modus?
Als u een variabele gebruikt zonder deze te declareren, wordt er een fout gegenereerd in de strikte modus. Dit is om te voorkomen dat er per ongeluk globale variabelen ontstaan ​​in uw applicatie. Vooral het voorbeeld met het drukken van Chicago dekt dit.
Het verwijderen van een variabele of een functie of een argument is een nee-nee in strikte modus.
"gebruik strikt";
functie x (p1, p2) {};
verwijder x; // Dit veroorzaakt een fout
Het dupliceren van een parameternaam is niet toegestaan ​​in de strikte modus.
"gebruik strikt";
functie x (p1, p1) {}; // Dit veroorzaakt een fout
Gereserveerde woorden in de Javascript-taal zijn niet toegestaan ​​in de strikte modus. De woorden zijn implementaties-interface, let, pakketten, privé, beschermd, openbaar. statisch en opbrengst
Voor een uitgebreidere lijst, bekijk de MDN-documentatie hier: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Zeer actieve vraag. Verdien 10 reputatie om deze vraag te beantwoorden. De reputatievereiste helpt deze vraag te beschermen tegen spam en niet-beantwoording.
Niet het antwoord waar je naar zoekt? Blader door andere vragen met de tag javascript syntax jslint use-strict of stel uw eigen vraag.